﻿//TODO: Deshadow: implement and Test

//using System;
//using System.Collections.Generic;
//using System.ComponentModel;
//using System.Drawing;
//using System.Linq;
//using System.Reflection;
//using System.Windows.Forms;
//using System.Drawing.Imaging;

//using LowLevelGraphics.ColorSpaces;

//namespace LowLevelGraphics.Filter
//{
//    /// <summary>
//    /// Tries to remove all shadows.
//    /// </summary>
//    public class Deshadow : BaseImageFilter
//    {
//        /// <summary>
//        /// Initializes a new instance of the <see cref="Deshadow"/> class.
//        /// </summary>
//        public Deshadow()
//        {
//        }

//        /// <summary>
//        /// Initializes a new instance of the <see cref="Deshadow"/> class.
//        /// </summary>
//        /// <param name="_deshadow">The _deshadow.</param>
//        internal Deshadow(Deshadow _deshadow)
//        {
//        }

//        /// <summary>
//        /// Execute this Filter
//        /// A Debug Statement is written if a concrete Filter is called
//        /// </summary>
//        /// <param name="_bitmap"></param>
//        /// <returns></returns>
//        public override UnsafeBitmap Execute(UnsafeBitmap _bitmap)
//        {
//            UnsafeBitmap bitmapTemp = _bitmap; //.ActivePictureBox.BackgroundImage;
//            int nMin = 0xFFFFFF;
//            int nMax = 0;

//            int nMinX = 0;
//            int nMaxX = 0;

//            List<Color> aColor = new List<Color>();
//            int nColorValue = 0;

//            int nHeight = bitmapTemp.Height;
//            int nWidth = bitmapTemp.Width;

//            int nCount = 0;
//            List<Color> aColorTemp = new List<Color>();
//            List<string> aTest = new List<string>();

//            int y = 0;
//            int x = 0;

//            float fBG = 0.0f;
//            float fRB = 0.0f;
//            float fRG = 0.0f;

//            Color color = Color.Transparent;

//            float bg = 0.0f;
//            float rb = 0.0f;
//            float rg = 0.0f;


//            Dictionary<ColorStructF, List<Color>> aRatio = new Dictionary<ColorStructF, List<Color>>();

//            ColorStructF f;

//            //First we get all the values that may have the same ratios.
//            //b/g, r/b, r/g
//            for (y = 0; y < nHeight; y++)
//            {
//                for (x = 0; x < nWidth; x++)
//                {
//                    color = bitmapTemp.GetPixel(x, y);

//                    bg = 0.0f;
//                    rb = 0.0f;
//                    rg = 0.0f;
//                    ColorFunctions.GetChannelRatios(color, out bg, out rb, out rg);

//                    f = new ColorStructF(bg, rb, rg);

//                    if (!aRatio.ContainsKey(f))
//                    {
//                        aRatio.Add(f, new List<Color>() { color });
//                    }
//                    else
//                    {
//                        if (!aRatio[f].Contains(color))
//                        {
//                            aRatio[f].Add(color);
//                        }
//                    }
//                    if (aRatio[f].Count > 1)
//                    {
//                    }
//                    nCount++;
//                }
//            }

//            Dictionary<int, int> aDeshadowMap = new Dictionary<int, int>();

//            int nMinTemp = int.MaxValue;
//            int nMaxTemp = 0;
//            foreach (KeyValuePair<ColorStructF, List<Color>> keyValuePair in aRatio)
//            {
//                nMaxTemp = 0;
//                nMinTemp = int.MaxValue;
//                if (keyValuePair.Value.Count > 1)
//                {
//                    foreach (Color colorTemp in keyValuePair.Value)
//                    {
//                        int nValue = ColorFunctions.ToIntRGB(colorTemp);
//                        if (nValue > nMaxTemp)
//                        {
//                            nMaxTemp = nValue;
//                            aDeshadowMap.Add(nMaxTemp, nMinTemp);
//                        }
//                        if (nValue < nMinTemp)
//                        {
//                            nMinTemp = nValue;
//                        }
//                    }
//                }
//            }

//            for (y = 0; y < nHeight; y++)
//            {
//                for (x = 0; x < nWidth; x++)
//                {
//                    int nValue = ColorFunctions.ToIntRGB(bitmapTemp.GetPixel(x, y));
//                    if (aDeshadowMap.ContainsKey(nValue))
//                    {
//                        bitmapTemp.SetPixel(x, y, Color.FromArgb(aDeshadowMap[nValue]));
//                    }
//                }
//            }

//            bitmapTemp.Dispose();
//            return _bitmap;
//        }

//        /// <summary>
//        /// This is used to clone a filter, each filter must implement it's own clone functionality
//        /// </summary>
//        /// <returns></returns>
//        public override object Clone()
//        {
//            return new Deshadow(this);
//        }
//    }
//}
